/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */



#ifndef IE_DEFINITIONS_READER_H
#define IE_DEFINITIONS_READER_H

/* Generated by flatcc 0.6.1-dev FlatBuffers schema compiler for C by dvide.com */

#ifndef FLATBUFFERS_COMMON_READER_H
#include "flatbuffers_common_reader.h"
#endif
#include "flatcc/flatcc_flatbuffers.h"
#ifndef __alignas_is_defined
#include <stdalign.h>
#endif
#include "flatcc/flatcc_prologue.h"
#ifndef flatbuffers_identifier
#define flatbuffers_identifier 0
#endif
#ifndef flatbuffers_extension
#define flatbuffers_extension ".bin"
#endif

typedef struct e2ap_RicRequestId e2ap_RicRequestId_t;
typedef const e2ap_RicRequestId_t *e2ap_RicRequestId_struct_t;
typedef e2ap_RicRequestId_t *e2ap_RicRequestId_mutable_struct_t;
typedef const e2ap_RicRequestId_t *e2ap_RicRequestId_vec_t;
typedef e2ap_RicRequestId_t *e2ap_RicRequestId_mutable_vec_t;
typedef struct e2ap_E2NCId e2ap_E2NCId_t;
typedef const e2ap_E2NCId_t *e2ap_E2NCId_struct_t;
typedef e2ap_E2NCId_t *e2ap_E2NCId_mutable_struct_t;
typedef const e2ap_E2NCId_t *e2ap_E2NCId_vec_t;
typedef e2ap_E2NCId_t *e2ap_E2NCId_mutable_vec_t;
typedef struct e2ap_Plmn e2ap_Plmn_t;
typedef const e2ap_Plmn_t *e2ap_Plmn_struct_t;
typedef e2ap_Plmn_t *e2ap_Plmn_mutable_struct_t;
typedef const e2ap_Plmn_t *e2ap_Plmn_vec_t;
typedef e2ap_Plmn_t *e2ap_Plmn_mutable_vec_t;
typedef struct e2ap_EngNB e2ap_EngNB_t;
typedef const e2ap_EngNB_t *e2ap_EngNB_struct_t;
typedef e2ap_EngNB_t *e2ap_EngNB_mutable_struct_t;
typedef const e2ap_EngNB_t *e2ap_EngNB_vec_t;
typedef e2ap_EngNB_t *e2ap_EngNB_mutable_vec_t;
typedef struct e2ap_NgeNB e2ap_NgeNB_t;
typedef const e2ap_NgeNB_t *e2ap_NgeNB_struct_t;
typedef e2ap_NgeNB_t *e2ap_NgeNB_mutable_struct_t;
typedef const e2ap_NgeNB_t *e2ap_NgeNB_vec_t;
typedef e2ap_NgeNB_t *e2ap_NgeNB_mutable_vec_t;
typedef struct e2ap_ENB e2ap_ENB_t;
typedef const e2ap_ENB_t *e2ap_ENB_struct_t;
typedef e2ap_ENB_t *e2ap_ENB_mutable_struct_t;
typedef const e2ap_ENB_t *e2ap_ENB_vec_t;
typedef e2ap_ENB_t *e2ap_ENB_mutable_vec_t;

typedef const struct e2ap_RicRequest_table *e2ap_RicRequest_table_t;
typedef struct e2ap_RicRequest_table *e2ap_RicRequest_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_RicRequest_vec_t;
typedef flatbuffers_uoffset_t *e2ap_RicRequest_mutable_vec_t;
typedef const struct e2ap_RicService_table *e2ap_RicService_table_t;
typedef struct e2ap_RicService_table *e2ap_RicService_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_RicService_vec_t;
typedef flatbuffers_uoffset_t *e2ap_RicService_mutable_vec_t;
typedef const struct e2ap_TransportLayer_table *e2ap_TransportLayer_table_t;
typedef struct e2ap_TransportLayer_table *e2ap_TransportLayer_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_TransportLayer_vec_t;
typedef flatbuffers_uoffset_t *e2ap_TransportLayer_mutable_vec_t;
typedef const struct e2ap_Protocol_table *e2ap_Protocol_table_t;
typedef struct e2ap_Protocol_table *e2ap_Protocol_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_Protocol_vec_t;
typedef flatbuffers_uoffset_t *e2ap_Protocol_mutable_vec_t;
typedef const struct e2ap_Misc_table *e2ap_Misc_table_t;
typedef struct e2ap_Misc_table *e2ap_Misc_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_Misc_vec_t;
typedef flatbuffers_uoffset_t *e2ap_Misc_mutable_vec_t;
typedef const struct e2ap_IECriticalityDiagnostics_table *e2ap_IECriticalityDiagnostics_table_t;
typedef struct e2ap_IECriticalityDiagnostics_table *e2ap_IECriticalityDiagnostics_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_IECriticalityDiagnostics_vec_t;
typedef flatbuffers_uoffset_t *e2ap_IECriticalityDiagnostics_mutable_vec_t;
typedef const struct e2ap_CriticalityDiagnostics_table *e2ap_CriticalityDiagnostics_table_t;
typedef struct e2ap_CriticalityDiagnostics_table *e2ap_CriticalityDiagnostics_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_CriticalityDiagnostics_vec_t;
typedef flatbuffers_uoffset_t *e2ap_CriticalityDiagnostics_mutable_vec_t;
typedef const struct e2ap_GlobalRicId_table *e2ap_GlobalRicId_table_t;
typedef struct e2ap_GlobalRicId_table *e2ap_GlobalRicId_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_GlobalRicId_vec_t;
typedef flatbuffers_uoffset_t *e2ap_GlobalRicId_mutable_vec_t;
typedef const struct e2ap_RicSubsequentAction_table *e2ap_RicSubsequentAction_table_t;
typedef struct e2ap_RicSubsequentAction_table *e2ap_RicSubsequentAction_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_RicSubsequentAction_vec_t;
typedef flatbuffers_uoffset_t *e2ap_RicSubsequentAction_mutable_vec_t;
typedef const struct e2ap_gnbE2NodeCompConfUpdate_table *e2ap_gnbE2NodeCompConfUpdate_table_t;
typedef struct e2ap_gnbE2NodeCompConfUpdate_table *e2ap_gnbE2NodeCompConfUpdate_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_gnbE2NodeCompConfUpdate_vec_t;
typedef flatbuffers_uoffset_t *e2ap_gnbE2NodeCompConfUpdate_mutable_vec_t;
typedef const struct e2ap_en_gnbE2NodeCompConfUpdate_table *e2ap_en_gnbE2NodeCompConfUpdate_table_t;
typedef struct e2ap_en_gnbE2NodeCompConfUpdate_table *e2ap_en_gnbE2NodeCompConfUpdate_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_en_gnbE2NodeCompConfUpdate_vec_t;
typedef flatbuffers_uoffset_t *e2ap_en_gnbE2NodeCompConfUpdate_mutable_vec_t;
typedef const struct e2ap_ng_enbE2NodeCompConfUpdate_table *e2ap_ng_enbE2NodeCompConfUpdate_table_t;
typedef struct e2ap_ng_enbE2NodeCompConfUpdate_table *e2ap_ng_enbE2NodeCompConfUpdate_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_ng_enbE2NodeCompConfUpdate_vec_t;
typedef flatbuffers_uoffset_t *e2ap_ng_enbE2NodeCompConfUpdate_mutable_vec_t;
typedef const struct e2ap_enbE2NodeCompConfUpdate_table *e2ap_enbE2NodeCompConfUpdate_table_t;
typedef struct e2ap_enbE2NodeCompConfUpdate_table *e2ap_enbE2NodeCompConfUpdate_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_enbE2NodeCompConfUpdate_vec_t;
typedef flatbuffers_uoffset_t *e2ap_enbE2NodeCompConfUpdate_mutable_vec_t;
typedef const struct e2ap_E2NodeCompConfUpdateAck_table *e2ap_E2NodeCompConfUpdateAck_table_t;
typedef struct e2ap_E2NodeCompConfUpdateAck_table *e2ap_E2NodeCompConfUpdateAck_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_E2NodeCompConfUpdateAck_vec_t;
typedef flatbuffers_uoffset_t *e2ap_E2NodeCompConfUpdateAck_mutable_vec_t;
typedef const struct e2ap_TransportLayerInformation_table *e2ap_TransportLayerInformation_table_t;
typedef struct e2ap_TransportLayerInformation_table *e2ap_TransportLayerInformation_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_TransportLayerInformation_vec_t;
typedef flatbuffers_uoffset_t *e2ap_TransportLayerInformation_mutable_vec_t;
typedef const struct e2ap_GNB_table *e2ap_GNB_table_t;
typedef struct e2ap_GNB_table *e2ap_GNB_mutable_table_t;
typedef const flatbuffers_uoffset_t *e2ap_GNB_vec_t;
typedef flatbuffers_uoffset_t *e2ap_GNB_mutable_vec_t;
#ifndef e2ap_RicRequest_file_identifier
#define e2ap_RicRequest_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_RicRequest_file_identifier */
#ifndef e2ap_RicRequest_identifier
#define e2ap_RicRequest_identifier flatbuffers_identifier
#endif
#define e2ap_RicRequest_type_hash ((flatbuffers_thash_t)0xaf4b2778)
#define e2ap_RicRequest_type_identifier "\x78\x27\x4b\xaf"
#ifndef e2ap_RicService_file_identifier
#define e2ap_RicService_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_RicService_file_identifier */
#ifndef e2ap_RicService_identifier
#define e2ap_RicService_identifier flatbuffers_identifier
#endif
#define e2ap_RicService_type_hash ((flatbuffers_thash_t)0x83d1ceca)
#define e2ap_RicService_type_identifier "\xca\xce\xd1\x83"
#ifndef e2ap_TransportLayer_file_identifier
#define e2ap_TransportLayer_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_TransportLayer_file_identifier */
#ifndef e2ap_TransportLayer_identifier
#define e2ap_TransportLayer_identifier flatbuffers_identifier
#endif
#define e2ap_TransportLayer_type_hash ((flatbuffers_thash_t)0xc8b53fad)
#define e2ap_TransportLayer_type_identifier "\xad\x3f\xb5\xc8"
#ifndef e2ap_Protocol_file_identifier
#define e2ap_Protocol_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_Protocol_file_identifier */
#ifndef e2ap_Protocol_identifier
#define e2ap_Protocol_identifier flatbuffers_identifier
#endif
#define e2ap_Protocol_type_hash ((flatbuffers_thash_t)0xac95b127)
#define e2ap_Protocol_type_identifier "\x27\xb1\x95\xac"
#ifndef e2ap_Misc_file_identifier
#define e2ap_Misc_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_Misc_file_identifier */
#ifndef e2ap_Misc_identifier
#define e2ap_Misc_identifier flatbuffers_identifier
#endif
#define e2ap_Misc_type_hash ((flatbuffers_thash_t)0x59d0a547)
#define e2ap_Misc_type_identifier "\x47\xa5\xd0\x59"
#ifndef e2ap_IECriticalityDiagnostics_file_identifier
#define e2ap_IECriticalityDiagnostics_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_IECriticalityDiagnostics_file_identifier */
#ifndef e2ap_IECriticalityDiagnostics_identifier
#define e2ap_IECriticalityDiagnostics_identifier flatbuffers_identifier
#endif
#define e2ap_IECriticalityDiagnostics_type_hash ((flatbuffers_thash_t)0x27a85cb4)
#define e2ap_IECriticalityDiagnostics_type_identifier "\xb4\x5c\xa8\x27"
#ifndef e2ap_CriticalityDiagnostics_file_identifier
#define e2ap_CriticalityDiagnostics_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_CriticalityDiagnostics_file_identifier */
#ifndef e2ap_CriticalityDiagnostics_identifier
#define e2ap_CriticalityDiagnostics_identifier flatbuffers_identifier
#endif
#define e2ap_CriticalityDiagnostics_type_hash ((flatbuffers_thash_t)0x4c2abb2a)
#define e2ap_CriticalityDiagnostics_type_identifier "\x2a\xbb\x2a\x4c"
#ifndef e2ap_GlobalRicId_file_identifier
#define e2ap_GlobalRicId_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_GlobalRicId_file_identifier */
#ifndef e2ap_GlobalRicId_identifier
#define e2ap_GlobalRicId_identifier flatbuffers_identifier
#endif
#define e2ap_GlobalRicId_type_hash ((flatbuffers_thash_t)0x1f6bf44f)
#define e2ap_GlobalRicId_type_identifier "\x4f\xf4\x6b\x1f"
#ifndef e2ap_RicRequestId_file_identifier
#define e2ap_RicRequestId_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_RicRequestId_file_identifier */
#ifndef e2ap_RicRequestId_identifier
#define e2ap_RicRequestId_identifier flatbuffers_identifier
#endif
#define e2ap_RicRequestId_type_hash ((flatbuffers_thash_t)0x6ee2a5c5)
#define e2ap_RicRequestId_type_identifier "\xc5\xa5\xe2\x6e"
#ifndef e2ap_RicSubsequentAction_file_identifier
#define e2ap_RicSubsequentAction_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_RicSubsequentAction_file_identifier */
#ifndef e2ap_RicSubsequentAction_identifier
#define e2ap_RicSubsequentAction_identifier flatbuffers_identifier
#endif
#define e2ap_RicSubsequentAction_type_hash ((flatbuffers_thash_t)0x4794f9d8)
#define e2ap_RicSubsequentAction_type_identifier "\xd8\xf9\x94\x47"
#ifndef e2ap_gnbE2NodeCompConfUpdate_file_identifier
#define e2ap_gnbE2NodeCompConfUpdate_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_gnbE2NodeCompConfUpdate_file_identifier */
#ifndef e2ap_gnbE2NodeCompConfUpdate_identifier
#define e2ap_gnbE2NodeCompConfUpdate_identifier flatbuffers_identifier
#endif
#define e2ap_gnbE2NodeCompConfUpdate_type_hash ((flatbuffers_thash_t)0x883635d7)
#define e2ap_gnbE2NodeCompConfUpdate_type_identifier "\xd7\x35\x36\x88"
#ifndef e2ap_en_gnbE2NodeCompConfUpdate_file_identifier
#define e2ap_en_gnbE2NodeCompConfUpdate_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_en_gnbE2NodeCompConfUpdate_file_identifier */
#ifndef e2ap_en_gnbE2NodeCompConfUpdate_identifier
#define e2ap_en_gnbE2NodeCompConfUpdate_identifier flatbuffers_identifier
#endif
#define e2ap_en_gnbE2NodeCompConfUpdate_type_hash ((flatbuffers_thash_t)0xe73fa109)
#define e2ap_en_gnbE2NodeCompConfUpdate_type_identifier "\x09\xa1\x3f\xe7"
#ifndef e2ap_ng_enbE2NodeCompConfUpdate_file_identifier
#define e2ap_ng_enbE2NodeCompConfUpdate_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_ng_enbE2NodeCompConfUpdate_file_identifier */
#ifndef e2ap_ng_enbE2NodeCompConfUpdate_identifier
#define e2ap_ng_enbE2NodeCompConfUpdate_identifier flatbuffers_identifier
#endif
#define e2ap_ng_enbE2NodeCompConfUpdate_type_hash ((flatbuffers_thash_t)0xb49dd37b)
#define e2ap_ng_enbE2NodeCompConfUpdate_type_identifier "\x7b\xd3\x9d\xb4"
#ifndef e2ap_enbE2NodeCompConfUpdate_file_identifier
#define e2ap_enbE2NodeCompConfUpdate_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_enbE2NodeCompConfUpdate_file_identifier */
#ifndef e2ap_enbE2NodeCompConfUpdate_identifier
#define e2ap_enbE2NodeCompConfUpdate_identifier flatbuffers_identifier
#endif
#define e2ap_enbE2NodeCompConfUpdate_type_hash ((flatbuffers_thash_t)0xe6f2159)
#define e2ap_enbE2NodeCompConfUpdate_type_identifier "\x59\x21\x6f\x0e"
#ifndef e2ap_E2NodeCompConfUpdateAck_file_identifier
#define e2ap_E2NodeCompConfUpdateAck_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_E2NodeCompConfUpdateAck_file_identifier */
#ifndef e2ap_E2NodeCompConfUpdateAck_identifier
#define e2ap_E2NodeCompConfUpdateAck_identifier flatbuffers_identifier
#endif
#define e2ap_E2NodeCompConfUpdateAck_type_hash ((flatbuffers_thash_t)0x1dd96395)
#define e2ap_E2NodeCompConfUpdateAck_type_identifier "\x95\x63\xd9\x1d"
#ifndef e2ap_TransportLayerInformation_file_identifier
#define e2ap_TransportLayerInformation_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_TransportLayerInformation_file_identifier */
#ifndef e2ap_TransportLayerInformation_identifier
#define e2ap_TransportLayerInformation_identifier flatbuffers_identifier
#endif
#define e2ap_TransportLayerInformation_type_hash ((flatbuffers_thash_t)0xa566785d)
#define e2ap_TransportLayerInformation_type_identifier "\x5d\x78\x66\xa5"
#ifndef e2ap_E2NCId_file_identifier
#define e2ap_E2NCId_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_E2NCId_file_identifier */
#ifndef e2ap_E2NCId_identifier
#define e2ap_E2NCId_identifier flatbuffers_identifier
#endif
#define e2ap_E2NCId_type_hash ((flatbuffers_thash_t)0x92526bc6)
#define e2ap_E2NCId_type_identifier "\xc6\x6b\x52\x92"
#ifndef e2ap_Plmn_file_identifier
#define e2ap_Plmn_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_Plmn_file_identifier */
#ifndef e2ap_Plmn_identifier
#define e2ap_Plmn_identifier flatbuffers_identifier
#endif
#define e2ap_Plmn_type_hash ((flatbuffers_thash_t)0x89601708)
#define e2ap_Plmn_type_identifier "\x08\x17\x60\x89"
#ifndef e2ap_GNB_file_identifier
#define e2ap_GNB_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_GNB_file_identifier */
#ifndef e2ap_GNB_identifier
#define e2ap_GNB_identifier flatbuffers_identifier
#endif
#define e2ap_GNB_type_hash ((flatbuffers_thash_t)0xfbe8a76c)
#define e2ap_GNB_type_identifier "\x6c\xa7\xe8\xfb"
#ifndef e2ap_EngNB_file_identifier
#define e2ap_EngNB_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_EngNB_file_identifier */
#ifndef e2ap_EngNB_identifier
#define e2ap_EngNB_identifier flatbuffers_identifier
#endif
#define e2ap_EngNB_type_hash ((flatbuffers_thash_t)0x66a01e85)
#define e2ap_EngNB_type_identifier "\x85\x1e\xa0\x66"
#ifndef e2ap_NgeNB_file_identifier
#define e2ap_NgeNB_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_NgeNB_file_identifier */
#ifndef e2ap_NgeNB_identifier
#define e2ap_NgeNB_identifier flatbuffers_identifier
#endif
#define e2ap_NgeNB_type_hash ((flatbuffers_thash_t)0x74a41783)
#define e2ap_NgeNB_type_identifier "\x83\x17\xa4\x74"
#ifndef e2ap_ENB_file_identifier
#define e2ap_ENB_file_identifier flatbuffers_identifier
#endif
/* deprecated, use e2ap_ENB_file_identifier */
#ifndef e2ap_ENB_identifier
#define e2ap_ENB_identifier flatbuffers_identifier
#endif
#define e2ap_ENB_type_hash ((flatbuffers_thash_t)0xf5e6db02)
#define e2ap_ENB_type_identifier "\x02\xdb\xe6\xf5"

typedef uint8_t e2ap_RicRequestCause_enum_t;
__flatbuffers_define_integer_type(e2ap_RicRequestCause, e2ap_RicRequestCause_enum_t, 8)
#define e2ap_RicRequestCause_RanFunctionIdInvalid ((e2ap_RicRequestCause_enum_t)UINT8_C(0))
#define e2ap_RicRequestCause_ActionNotSupported ((e2ap_RicRequestCause_enum_t)UINT8_C(1))
#define e2ap_RicRequestCause_ExcessiveActions ((e2ap_RicRequestCause_enum_t)UINT8_C(2))
#define e2ap_RicRequestCause_DuplicateAction ((e2ap_RicRequestCause_enum_t)UINT8_C(3))
#define e2ap_RicRequestCause_DuplicateEventTrigger ((e2ap_RicRequestCause_enum_t)UINT8_C(4))
#define e2ap_RicRequestCause_FunctionResourceLimit ((e2ap_RicRequestCause_enum_t)UINT8_C(5))
#define e2ap_RicRequestCause_RicRequestIdUnknown ((e2ap_RicRequestCause_enum_t)UINT8_C(6))
#define e2ap_RicRequestCause_InconsistentActionSubsequentActionSequence ((e2ap_RicRequestCause_enum_t)UINT8_C(7))
#define e2ap_RicRequestCause_ControlMessageInvalid ((e2ap_RicRequestCause_enum_t)UINT8_C(8))
#define e2ap_RicRequestCause_RicCallProcessIdInvalid ((e2ap_RicRequestCause_enum_t)UINT8_C(9))
#define e2ap_RicRequestCause_RicReqUnspecified ((e2ap_RicRequestCause_enum_t)UINT8_C(10))

static inline const char *e2ap_RicRequestCause_name(e2ap_RicRequestCause_enum_t value)
{
    switch (value) {
    case e2ap_RicRequestCause_RanFunctionIdInvalid: return "RanFunctionIdInvalid";
    case e2ap_RicRequestCause_ActionNotSupported: return "ActionNotSupported";
    case e2ap_RicRequestCause_ExcessiveActions: return "ExcessiveActions";
    case e2ap_RicRequestCause_DuplicateAction: return "DuplicateAction";
    case e2ap_RicRequestCause_DuplicateEventTrigger: return "DuplicateEventTrigger";
    case e2ap_RicRequestCause_FunctionResourceLimit: return "FunctionResourceLimit";
    case e2ap_RicRequestCause_RicRequestIdUnknown: return "RicRequestIdUnknown";
    case e2ap_RicRequestCause_InconsistentActionSubsequentActionSequence: return "InconsistentActionSubsequentActionSequence";
    case e2ap_RicRequestCause_ControlMessageInvalid: return "ControlMessageInvalid";
    case e2ap_RicRequestCause_RicCallProcessIdInvalid: return "RicCallProcessIdInvalid";
    case e2ap_RicRequestCause_RicReqUnspecified: return "RicReqUnspecified";
    default: return "";
    }
}

static inline int e2ap_RicRequestCause_is_known_value(e2ap_RicRequestCause_enum_t value)
{
    switch (value) {
    case e2ap_RicRequestCause_RanFunctionIdInvalid: return 1;
    case e2ap_RicRequestCause_ActionNotSupported: return 1;
    case e2ap_RicRequestCause_ExcessiveActions: return 1;
    case e2ap_RicRequestCause_DuplicateAction: return 1;
    case e2ap_RicRequestCause_DuplicateEventTrigger: return 1;
    case e2ap_RicRequestCause_FunctionResourceLimit: return 1;
    case e2ap_RicRequestCause_RicRequestIdUnknown: return 1;
    case e2ap_RicRequestCause_InconsistentActionSubsequentActionSequence: return 1;
    case e2ap_RicRequestCause_ControlMessageInvalid: return 1;
    case e2ap_RicRequestCause_RicCallProcessIdInvalid: return 1;
    case e2ap_RicRequestCause_RicReqUnspecified: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_RicServiceCause_enum_t;
__flatbuffers_define_integer_type(e2ap_RicServiceCause, e2ap_RicServiceCause_enum_t, 8)
#define e2ap_RicServiceCause_FunctionNotRequired ((e2ap_RicServiceCause_enum_t)UINT8_C(0))
#define e2ap_RicServiceCause_ExcessiveFunctions ((e2ap_RicServiceCause_enum_t)UINT8_C(1))
#define e2ap_RicServiceCause_RicResourceLimit ((e2ap_RicServiceCause_enum_t)UINT8_C(2))

static inline const char *e2ap_RicServiceCause_name(e2ap_RicServiceCause_enum_t value)
{
    switch (value) {
    case e2ap_RicServiceCause_FunctionNotRequired: return "FunctionNotRequired";
    case e2ap_RicServiceCause_ExcessiveFunctions: return "ExcessiveFunctions";
    case e2ap_RicServiceCause_RicResourceLimit: return "RicResourceLimit";
    default: return "";
    }
}

static inline int e2ap_RicServiceCause_is_known_value(e2ap_RicServiceCause_enum_t value)
{
    switch (value) {
    case e2ap_RicServiceCause_FunctionNotRequired: return 1;
    case e2ap_RicServiceCause_ExcessiveFunctions: return 1;
    case e2ap_RicServiceCause_RicResourceLimit: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_TransportLayerCause_enum_t;
__flatbuffers_define_integer_type(e2ap_TransportLayerCause, e2ap_TransportLayerCause_enum_t, 8)
#define e2ap_TransportLayerCause_Unspecified ((e2ap_TransportLayerCause_enum_t)UINT8_C(0))
#define e2ap_TransportLayerCause_TransportResourceUnavailable ((e2ap_TransportLayerCause_enum_t)UINT8_C(1))

static inline const char *e2ap_TransportLayerCause_name(e2ap_TransportLayerCause_enum_t value)
{
    switch (value) {
    case e2ap_TransportLayerCause_Unspecified: return "Unspecified";
    case e2ap_TransportLayerCause_TransportResourceUnavailable: return "TransportResourceUnavailable";
    default: return "";
    }
}

static inline int e2ap_TransportLayerCause_is_known_value(e2ap_TransportLayerCause_enum_t value)
{
    switch (value) {
    case e2ap_TransportLayerCause_Unspecified: return 1;
    case e2ap_TransportLayerCause_TransportResourceUnavailable: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_ProtocolCause_enum_t;
__flatbuffers_define_integer_type(e2ap_ProtocolCause, e2ap_ProtocolCause_enum_t, 8)
#define e2ap_ProtocolCause_TransferSyntaxError ((e2ap_ProtocolCause_enum_t)UINT8_C(0))
#define e2ap_ProtocolCause_AbstractSyntaxErrorReject ((e2ap_ProtocolCause_enum_t)UINT8_C(1))
#define e2ap_ProtocolCause_AbstractSyntaxErrorIgnoreAndNotify ((e2ap_ProtocolCause_enum_t)UINT8_C(2))
#define e2ap_ProtocolCause_MessageNotCompatibleWithReceiverState ((e2ap_ProtocolCause_enum_t)UINT8_C(3))
#define e2ap_ProtocolCause_SemanticError ((e2ap_ProtocolCause_enum_t)UINT8_C(4))
#define e2ap_ProtocolCause_AbstractSyntaxErrorFalselyConstructedMessage ((e2ap_ProtocolCause_enum_t)UINT8_C(5))
#define e2ap_ProtocolCause_ProtUnspecified ((e2ap_ProtocolCause_enum_t)UINT8_C(6))

static inline const char *e2ap_ProtocolCause_name(e2ap_ProtocolCause_enum_t value)
{
    switch (value) {
    case e2ap_ProtocolCause_TransferSyntaxError: return "TransferSyntaxError";
    case e2ap_ProtocolCause_AbstractSyntaxErrorReject: return "AbstractSyntaxErrorReject";
    case e2ap_ProtocolCause_AbstractSyntaxErrorIgnoreAndNotify: return "AbstractSyntaxErrorIgnoreAndNotify";
    case e2ap_ProtocolCause_MessageNotCompatibleWithReceiverState: return "MessageNotCompatibleWithReceiverState";
    case e2ap_ProtocolCause_SemanticError: return "SemanticError";
    case e2ap_ProtocolCause_AbstractSyntaxErrorFalselyConstructedMessage: return "AbstractSyntaxErrorFalselyConstructedMessage";
    case e2ap_ProtocolCause_ProtUnspecified: return "ProtUnspecified";
    default: return "";
    }
}

static inline int e2ap_ProtocolCause_is_known_value(e2ap_ProtocolCause_enum_t value)
{
    switch (value) {
    case e2ap_ProtocolCause_TransferSyntaxError: return 1;
    case e2ap_ProtocolCause_AbstractSyntaxErrorReject: return 1;
    case e2ap_ProtocolCause_AbstractSyntaxErrorIgnoreAndNotify: return 1;
    case e2ap_ProtocolCause_MessageNotCompatibleWithReceiverState: return 1;
    case e2ap_ProtocolCause_SemanticError: return 1;
    case e2ap_ProtocolCause_AbstractSyntaxErrorFalselyConstructedMessage: return 1;
    case e2ap_ProtocolCause_ProtUnspecified: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_MiscellaneousCause_enum_t;
__flatbuffers_define_integer_type(e2ap_MiscellaneousCause, e2ap_MiscellaneousCause_enum_t, 8)
#define e2ap_MiscellaneousCause_ControlProcessingOverload ((e2ap_MiscellaneousCause_enum_t)UINT8_C(0))
#define e2ap_MiscellaneousCause_HardwareFailure ((e2ap_MiscellaneousCause_enum_t)UINT8_C(1))
#define e2ap_MiscellaneousCause_OMIntervention ((e2ap_MiscellaneousCause_enum_t)UINT8_C(2))
#define e2ap_MiscellaneousCause_MiscUnspecified ((e2ap_MiscellaneousCause_enum_t)UINT8_C(3))

static inline const char *e2ap_MiscellaneousCause_name(e2ap_MiscellaneousCause_enum_t value)
{
    switch (value) {
    case e2ap_MiscellaneousCause_ControlProcessingOverload: return "ControlProcessingOverload";
    case e2ap_MiscellaneousCause_HardwareFailure: return "HardwareFailure";
    case e2ap_MiscellaneousCause_OMIntervention: return "OMIntervention";
    case e2ap_MiscellaneousCause_MiscUnspecified: return "MiscUnspecified";
    default: return "";
    }
}

static inline int e2ap_MiscellaneousCause_is_known_value(e2ap_MiscellaneousCause_enum_t value)
{
    switch (value) {
    case e2ap_MiscellaneousCause_ControlProcessingOverload: return 1;
    case e2ap_MiscellaneousCause_HardwareFailure: return 1;
    case e2ap_MiscellaneousCause_OMIntervention: return 1;
    case e2ap_MiscellaneousCause_MiscUnspecified: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_Criticality_enum_t;
__flatbuffers_define_integer_type(e2ap_Criticality, e2ap_Criticality_enum_t, 8)
#define e2ap_Criticality_Reject ((e2ap_Criticality_enum_t)UINT8_C(0))
#define e2ap_Criticality_Ignore ((e2ap_Criticality_enum_t)UINT8_C(1))
#define e2ap_Criticality_Notify ((e2ap_Criticality_enum_t)UINT8_C(2))

static inline const char *e2ap_Criticality_name(e2ap_Criticality_enum_t value)
{
    switch (value) {
    case e2ap_Criticality_Reject: return "Reject";
    case e2ap_Criticality_Ignore: return "Ignore";
    case e2ap_Criticality_Notify: return "Notify";
    default: return "";
    }
}

static inline int e2ap_Criticality_is_known_value(e2ap_Criticality_enum_t value)
{
    switch (value) {
    case e2ap_Criticality_Reject: return 1;
    case e2ap_Criticality_Ignore: return 1;
    case e2ap_Criticality_Notify: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_TypeOfError_enum_t;
__flatbuffers_define_integer_type(e2ap_TypeOfError, e2ap_TypeOfError_enum_t, 8)
#define e2ap_TypeOfError_NotUnderstood ((e2ap_TypeOfError_enum_t)UINT8_C(0))
#define e2ap_TypeOfError_Missing ((e2ap_TypeOfError_enum_t)UINT8_C(1))

static inline const char *e2ap_TypeOfError_name(e2ap_TypeOfError_enum_t value)
{
    switch (value) {
    case e2ap_TypeOfError_NotUnderstood: return "NotUnderstood";
    case e2ap_TypeOfError_Missing: return "Missing";
    default: return "";
    }
}

static inline int e2ap_TypeOfError_is_known_value(e2ap_TypeOfError_enum_t value)
{
    switch (value) {
    case e2ap_TypeOfError_NotUnderstood: return 1;
    case e2ap_TypeOfError_Missing: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_TriggeringMessage_enum_t;
__flatbuffers_define_integer_type(e2ap_TriggeringMessage, e2ap_TriggeringMessage_enum_t, 8)
#define e2ap_TriggeringMessage_InitiatingMessage ((e2ap_TriggeringMessage_enum_t)UINT8_C(0))
#define e2ap_TriggeringMessage_SuccessfulOutcome ((e2ap_TriggeringMessage_enum_t)UINT8_C(1))
#define e2ap_TriggeringMessage_UnsuccessfulOutcome ((e2ap_TriggeringMessage_enum_t)UINT8_C(2))

static inline const char *e2ap_TriggeringMessage_name(e2ap_TriggeringMessage_enum_t value)
{
    switch (value) {
    case e2ap_TriggeringMessage_InitiatingMessage: return "InitiatingMessage";
    case e2ap_TriggeringMessage_SuccessfulOutcome: return "SuccessfulOutcome";
    case e2ap_TriggeringMessage_UnsuccessfulOutcome: return "UnsuccessfulOutcome";
    default: return "";
    }
}

static inline int e2ap_TriggeringMessage_is_known_value(e2ap_TriggeringMessage_enum_t value)
{
    switch (value) {
    case e2ap_TriggeringMessage_InitiatingMessage: return 1;
    case e2ap_TriggeringMessage_SuccessfulOutcome: return 1;
    case e2ap_TriggeringMessage_UnsuccessfulOutcome: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_ProcedureCriticality_enum_t;
__flatbuffers_define_integer_type(e2ap_ProcedureCriticality, e2ap_ProcedureCriticality_enum_t, 8)
#define e2ap_ProcedureCriticality_Reject ((e2ap_ProcedureCriticality_enum_t)UINT8_C(0))
#define e2ap_ProcedureCriticality_Ignore ((e2ap_ProcedureCriticality_enum_t)UINT8_C(1))
#define e2ap_ProcedureCriticality_Notify ((e2ap_ProcedureCriticality_enum_t)UINT8_C(2))

static inline const char *e2ap_ProcedureCriticality_name(e2ap_ProcedureCriticality_enum_t value)
{
    switch (value) {
    case e2ap_ProcedureCriticality_Reject: return "Reject";
    case e2ap_ProcedureCriticality_Ignore: return "Ignore";
    case e2ap_ProcedureCriticality_Notify: return "Notify";
    default: return "";
    }
}

static inline int e2ap_ProcedureCriticality_is_known_value(e2ap_ProcedureCriticality_enum_t value)
{
    switch (value) {
    case e2ap_ProcedureCriticality_Reject: return 1;
    case e2ap_ProcedureCriticality_Ignore: return 1;
    case e2ap_ProcedureCriticality_Notify: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_RicActionType_enum_t;
__flatbuffers_define_integer_type(e2ap_RicActionType, e2ap_RicActionType_enum_t, 8)
#define e2ap_RicActionType_Report ((e2ap_RicActionType_enum_t)UINT8_C(0))
#define e2ap_RicActionType_Insert ((e2ap_RicActionType_enum_t)UINT8_C(1))
#define e2ap_RicActionType_Policy ((e2ap_RicActionType_enum_t)UINT8_C(2))

static inline const char *e2ap_RicActionType_name(e2ap_RicActionType_enum_t value)
{
    switch (value) {
    case e2ap_RicActionType_Report: return "Report";
    case e2ap_RicActionType_Insert: return "Insert";
    case e2ap_RicActionType_Policy: return "Policy";
    default: return "";
    }
}

static inline int e2ap_RicActionType_is_known_value(e2ap_RicActionType_enum_t value)
{
    switch (value) {
    case e2ap_RicActionType_Report: return 1;
    case e2ap_RicActionType_Insert: return 1;
    case e2ap_RicActionType_Policy: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_RicSubsequentActionType_enum_t;
__flatbuffers_define_integer_type(e2ap_RicSubsequentActionType, e2ap_RicSubsequentActionType_enum_t, 8)
#define e2ap_RicSubsequentActionType_Continue ((e2ap_RicSubsequentActionType_enum_t)UINT8_C(0))
#define e2ap_RicSubsequentActionType_Halt ((e2ap_RicSubsequentActionType_enum_t)UINT8_C(1))

static inline const char *e2ap_RicSubsequentActionType_name(e2ap_RicSubsequentActionType_enum_t value)
{
    switch (value) {
    case e2ap_RicSubsequentActionType_Continue: return "Continue";
    case e2ap_RicSubsequentActionType_Halt: return "Halt";
    default: return "";
    }
}

static inline int e2ap_RicSubsequentActionType_is_known_value(e2ap_RicSubsequentActionType_enum_t value)
{
    switch (value) {
    case e2ap_RicSubsequentActionType_Continue: return 1;
    case e2ap_RicSubsequentActionType_Halt: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_RicIndicationType_enum_t;
__flatbuffers_define_integer_type(e2ap_RicIndicationType, e2ap_RicIndicationType_enum_t, 8)
#define e2ap_RicIndicationType_Report ((e2ap_RicIndicationType_enum_t)UINT8_C(0))
#define e2ap_RicIndicationType_Insert ((e2ap_RicIndicationType_enum_t)UINT8_C(1))

static inline const char *e2ap_RicIndicationType_name(e2ap_RicIndicationType_enum_t value)
{
    switch (value) {
    case e2ap_RicIndicationType_Report: return "Report";
    case e2ap_RicIndicationType_Insert: return "Insert";
    default: return "";
    }
}

static inline int e2ap_RicIndicationType_is_known_value(e2ap_RicIndicationType_enum_t value)
{
    switch (value) {
    case e2ap_RicIndicationType_Report: return 1;
    case e2ap_RicIndicationType_Insert: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_RicControlAckRequest_enum_t;
__flatbuffers_define_integer_type(e2ap_RicControlAckRequest, e2ap_RicControlAckRequest_enum_t, 8)
#define e2ap_RicControlAckRequest_NoAck ((e2ap_RicControlAckRequest_enum_t)UINT8_C(0))
#define e2ap_RicControlAckRequest_Ack ((e2ap_RicControlAckRequest_enum_t)UINT8_C(1))
#define e2ap_RicControlAckRequest_NAck ((e2ap_RicControlAckRequest_enum_t)UINT8_C(2))

static inline const char *e2ap_RicControlAckRequest_name(e2ap_RicControlAckRequest_enum_t value)
{
    switch (value) {
    case e2ap_RicControlAckRequest_NoAck: return "NoAck";
    case e2ap_RicControlAckRequest_Ack: return "Ack";
    case e2ap_RicControlAckRequest_NAck: return "NAck";
    default: return "";
    }
}

static inline int e2ap_RicControlAckRequest_is_known_value(e2ap_RicControlAckRequest_enum_t value)
{
    switch (value) {
    case e2ap_RicControlAckRequest_NoAck: return 1;
    case e2ap_RicControlAckRequest_Ack: return 1;
    case e2ap_RicControlAckRequest_NAck: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_RicControlStatus_enum_t;
__flatbuffers_define_integer_type(e2ap_RicControlStatus, e2ap_RicControlStatus_enum_t, 8)
#define e2ap_RicControlStatus_Success ((e2ap_RicControlStatus_enum_t)UINT8_C(0))
#define e2ap_RicControlStatus_Rejected ((e2ap_RicControlStatus_enum_t)UINT8_C(1))
#define e2ap_RicControlStatus_Failed ((e2ap_RicControlStatus_enum_t)UINT8_C(2))

static inline const char *e2ap_RicControlStatus_name(e2ap_RicControlStatus_enum_t value)
{
    switch (value) {
    case e2ap_RicControlStatus_Success: return "Success";
    case e2ap_RicControlStatus_Rejected: return "Rejected";
    case e2ap_RicControlStatus_Failed: return "Failed";
    default: return "";
    }
}

static inline int e2ap_RicControlStatus_is_known_value(e2ap_RicControlStatus_enum_t value)
{
    switch (value) {
    case e2ap_RicControlStatus_Success: return 1;
    case e2ap_RicControlStatus_Rejected: return 1;
    case e2ap_RicControlStatus_Failed: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_E2NodeCompType_enum_t;
__flatbuffers_define_integer_type(e2ap_E2NodeCompType, e2ap_E2NodeCompType_enum_t, 8)
#define e2ap_E2NodeCompType_gNB ((e2ap_E2NodeCompType_enum_t)UINT8_C(0))
#define e2ap_E2NodeCompType_gNB_CU_UP ((e2ap_E2NodeCompType_enum_t)UINT8_C(1))
#define e2ap_E2NodeCompType_gNB_DU ((e2ap_E2NodeCompType_enum_t)UINT8_C(2))
#define e2ap_E2NodeCompType_en_gNB ((e2ap_E2NodeCompType_enum_t)UINT8_C(3))
#define e2ap_E2NodeCompType_eNB ((e2ap_E2NodeCompType_enum_t)UINT8_C(4))
#define e2ap_E2NodeCompType_ng_eNB ((e2ap_E2NodeCompType_enum_t)UINT8_C(5))

static inline const char *e2ap_E2NodeCompType_name(e2ap_E2NodeCompType_enum_t value)
{
    switch (value) {
    case e2ap_E2NodeCompType_gNB: return "gNB";
    case e2ap_E2NodeCompType_gNB_CU_UP: return "gNB_CU_UP";
    case e2ap_E2NodeCompType_gNB_DU: return "gNB_DU";
    case e2ap_E2NodeCompType_en_gNB: return "en_gNB";
    case e2ap_E2NodeCompType_eNB: return "eNB";
    case e2ap_E2NodeCompType_ng_eNB: return "ng_eNB";
    default: return "";
    }
}

static inline int e2ap_E2NodeCompType_is_known_value(e2ap_E2NodeCompType_enum_t value)
{
    switch (value) {
    case e2ap_E2NodeCompType_gNB: return 1;
    case e2ap_E2NodeCompType_gNB_CU_UP: return 1;
    case e2ap_E2NodeCompType_gNB_DU: return 1;
    case e2ap_E2NodeCompType_en_gNB: return 1;
    case e2ap_E2NodeCompType_eNB: return 1;
    case e2ap_E2NodeCompType_ng_eNB: return 1;
    default: return 0;
    }
}

typedef uint8_t e2ap_E2NodeCompConfUpdateAckOutcome_enum_t;
__flatbuffers_define_integer_type(e2ap_E2NodeCompConfUpdateAckOutcome, e2ap_E2NodeCompConfUpdateAckOutcome_enum_t, 8)
#define e2ap_E2NodeCompConfUpdateAckOutcome_Success ((e2ap_E2NodeCompConfUpdateAckOutcome_enum_t)UINT8_C(0))
#define e2ap_E2NodeCompConfUpdateAckOutcome_Failure ((e2ap_E2NodeCompConfUpdateAckOutcome_enum_t)UINT8_C(1))

static inline const char *e2ap_E2NodeCompConfUpdateAckOutcome_name(e2ap_E2NodeCompConfUpdateAckOutcome_enum_t value)
{
    switch (value) {
    case e2ap_E2NodeCompConfUpdateAckOutcome_Success: return "Success";
    case e2ap_E2NodeCompConfUpdateAckOutcome_Failure: return "Failure";
    default: return "";
    }
}

static inline int e2ap_E2NodeCompConfUpdateAckOutcome_is_known_value(e2ap_E2NodeCompConfUpdateAckOutcome_enum_t value)
{
    switch (value) {
    case e2ap_E2NodeCompConfUpdateAckOutcome_Success: return 1;
    case e2ap_E2NodeCompConfUpdateAckOutcome_Failure: return 1;
    default: return 0;
    }
}


struct e2ap_RicRequestId {
    alignas(2) uint16_t ricRequestorId;
    alignas(2) uint16_t ricInstanceId;
};
static_assert(sizeof(e2ap_RicRequestId_t) == 4, "struct size mismatch");

static inline const e2ap_RicRequestId_t *e2ap_RicRequestId__const_ptr_add(const e2ap_RicRequestId_t *p, size_t i) { return p + i; }
static inline e2ap_RicRequestId_t *e2ap_RicRequestId__ptr_add(e2ap_RicRequestId_t *p, size_t i) { return p + i; }
static inline e2ap_RicRequestId_struct_t e2ap_RicRequestId_vec_at(e2ap_RicRequestId_vec_t vec, size_t i)
__flatbuffers_struct_vec_at(vec, i)
static inline size_t e2ap_RicRequestId__size(void) { return 4; }
static inline size_t e2ap_RicRequestId_vec_len(e2ap_RicRequestId_vec_t vec)
__flatbuffers_vec_len(vec)
__flatbuffers_struct_as_root(e2ap_RicRequestId)

__flatbuffers_define_struct_scalar_field(e2ap_RicRequestId, ricRequestorId, flatbuffers_uint16, uint16_t)
__flatbuffers_define_struct_scalar_field(e2ap_RicRequestId, ricInstanceId, flatbuffers_uint16, uint16_t)

struct e2ap_E2NCId {
    alignas(8) uint64_t id;
};
static_assert(sizeof(e2ap_E2NCId_t) == 8, "struct size mismatch");

static inline const e2ap_E2NCId_t *e2ap_E2NCId__const_ptr_add(const e2ap_E2NCId_t *p, size_t i) { return p + i; }
static inline e2ap_E2NCId_t *e2ap_E2NCId__ptr_add(e2ap_E2NCId_t *p, size_t i) { return p + i; }
static inline e2ap_E2NCId_struct_t e2ap_E2NCId_vec_at(e2ap_E2NCId_vec_t vec, size_t i)
__flatbuffers_struct_vec_at(vec, i)
static inline size_t e2ap_E2NCId__size(void) { return 8; }
static inline size_t e2ap_E2NCId_vec_len(e2ap_E2NCId_vec_t vec)
__flatbuffers_vec_len(vec)
__flatbuffers_struct_as_root(e2ap_E2NCId)

__flatbuffers_define_struct_scalar_field(e2ap_E2NCId, id, flatbuffers_uint64, uint64_t)

struct e2ap_Plmn {
    alignas(2) uint16_t mcc;
    alignas(2) uint16_t mnc;
    alignas(1) uint8_t mnc_digit_length;
};
static_assert(sizeof(e2ap_Plmn_t) == 6, "struct size mismatch");

static inline const e2ap_Plmn_t *e2ap_Plmn__const_ptr_add(const e2ap_Plmn_t *p, size_t i) { return p + i; }
static inline e2ap_Plmn_t *e2ap_Plmn__ptr_add(e2ap_Plmn_t *p, size_t i) { return p + i; }
static inline e2ap_Plmn_struct_t e2ap_Plmn_vec_at(e2ap_Plmn_vec_t vec, size_t i)
__flatbuffers_struct_vec_at(vec, i)
static inline size_t e2ap_Plmn__size(void) { return 6; }
static inline size_t e2ap_Plmn_vec_len(e2ap_Plmn_vec_t vec)
__flatbuffers_vec_len(vec)
__flatbuffers_struct_as_root(e2ap_Plmn)

__flatbuffers_define_struct_scalar_field(e2ap_Plmn, mcc, flatbuffers_uint16, uint16_t)
__flatbuffers_define_struct_scalar_field(e2ap_Plmn, mnc, flatbuffers_uint16, uint16_t)
__flatbuffers_define_struct_scalar_field(e2ap_Plmn, mnc_digit_length, flatbuffers_uint8, uint8_t)

struct e2ap_EngNB {
    alignas(4) e2ap_Plmn_t plmn;
    alignas(4) uint32_t id;
};
static_assert(sizeof(e2ap_EngNB_t) == 12, "struct size mismatch");

static inline const e2ap_EngNB_t *e2ap_EngNB__const_ptr_add(const e2ap_EngNB_t *p, size_t i) { return p + i; }
static inline e2ap_EngNB_t *e2ap_EngNB__ptr_add(e2ap_EngNB_t *p, size_t i) { return p + i; }
static inline e2ap_EngNB_struct_t e2ap_EngNB_vec_at(e2ap_EngNB_vec_t vec, size_t i)
__flatbuffers_struct_vec_at(vec, i)
static inline size_t e2ap_EngNB__size(void) { return 12; }
static inline size_t e2ap_EngNB_vec_len(e2ap_EngNB_vec_t vec)
__flatbuffers_vec_len(vec)
__flatbuffers_struct_as_root(e2ap_EngNB)

__flatbuffers_define_struct_struct_field(e2ap_EngNB, plmn, e2ap_Plmn_struct_t)
__flatbuffers_define_struct_scalar_field(e2ap_EngNB, id, flatbuffers_uint32, uint32_t)

struct e2ap_NgeNB {
    alignas(4) e2ap_Plmn_t plmn;
    alignas(4) uint32_t id;
};
static_assert(sizeof(e2ap_NgeNB_t) == 12, "struct size mismatch");

static inline const e2ap_NgeNB_t *e2ap_NgeNB__const_ptr_add(const e2ap_NgeNB_t *p, size_t i) { return p + i; }
static inline e2ap_NgeNB_t *e2ap_NgeNB__ptr_add(e2ap_NgeNB_t *p, size_t i) { return p + i; }
static inline e2ap_NgeNB_struct_t e2ap_NgeNB_vec_at(e2ap_NgeNB_vec_t vec, size_t i)
__flatbuffers_struct_vec_at(vec, i)
static inline size_t e2ap_NgeNB__size(void) { return 12; }
static inline size_t e2ap_NgeNB_vec_len(e2ap_NgeNB_vec_t vec)
__flatbuffers_vec_len(vec)
__flatbuffers_struct_as_root(e2ap_NgeNB)

__flatbuffers_define_struct_struct_field(e2ap_NgeNB, plmn, e2ap_Plmn_struct_t)
__flatbuffers_define_struct_scalar_field(e2ap_NgeNB, id, flatbuffers_uint32, uint32_t)

struct e2ap_ENB {
    alignas(4) e2ap_Plmn_t plmn;
    alignas(4) uint32_t id;
};
static_assert(sizeof(e2ap_ENB_t) == 12, "struct size mismatch");

static inline const e2ap_ENB_t *e2ap_ENB__const_ptr_add(const e2ap_ENB_t *p, size_t i) { return p + i; }
static inline e2ap_ENB_t *e2ap_ENB__ptr_add(e2ap_ENB_t *p, size_t i) { return p + i; }
static inline e2ap_ENB_struct_t e2ap_ENB_vec_at(e2ap_ENB_vec_t vec, size_t i)
__flatbuffers_struct_vec_at(vec, i)
static inline size_t e2ap_ENB__size(void) { return 12; }
static inline size_t e2ap_ENB_vec_len(e2ap_ENB_vec_t vec)
__flatbuffers_vec_len(vec)
__flatbuffers_struct_as_root(e2ap_ENB)

__flatbuffers_define_struct_struct_field(e2ap_ENB, plmn, e2ap_Plmn_struct_t)
__flatbuffers_define_struct_scalar_field(e2ap_ENB, id, flatbuffers_uint32, uint32_t)


struct e2ap_RicRequest_table { uint8_t unused__; };

static inline size_t e2ap_RicRequest_vec_len(e2ap_RicRequest_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_RicRequest_table_t e2ap_RicRequest_vec_at(e2ap_RicRequest_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_RicRequest_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_RicRequest)

__flatbuffers_define_scalar_field(0, e2ap_RicRequest, ricRequestCause, e2ap_RicRequestCause, e2ap_RicRequestCause_enum_t, UINT8_C(0))

struct e2ap_RicService_table { uint8_t unused__; };

static inline size_t e2ap_RicService_vec_len(e2ap_RicService_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_RicService_table_t e2ap_RicService_vec_at(e2ap_RicService_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_RicService_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_RicService)

__flatbuffers_define_scalar_field(0, e2ap_RicService, ricServiceCause, e2ap_RicServiceCause, e2ap_RicServiceCause_enum_t, UINT8_C(0))

struct e2ap_TransportLayer_table { uint8_t unused__; };

static inline size_t e2ap_TransportLayer_vec_len(e2ap_TransportLayer_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_TransportLayer_table_t e2ap_TransportLayer_vec_at(e2ap_TransportLayer_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_TransportLayer_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_TransportLayer)

__flatbuffers_define_scalar_field(0, e2ap_TransportLayer, transportLayerCause, e2ap_TransportLayerCause, e2ap_TransportLayerCause_enum_t, UINT8_C(0))

struct e2ap_Protocol_table { uint8_t unused__; };

static inline size_t e2ap_Protocol_vec_len(e2ap_Protocol_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_Protocol_table_t e2ap_Protocol_vec_at(e2ap_Protocol_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_Protocol_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_Protocol)

__flatbuffers_define_scalar_field(0, e2ap_Protocol, protocolCause, e2ap_ProtocolCause, e2ap_ProtocolCause_enum_t, UINT8_C(0))

struct e2ap_Misc_table { uint8_t unused__; };

static inline size_t e2ap_Misc_vec_len(e2ap_Misc_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_Misc_table_t e2ap_Misc_vec_at(e2ap_Misc_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_Misc_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_Misc)

__flatbuffers_define_scalar_field(0, e2ap_Misc, miscellaneousCause, e2ap_MiscellaneousCause, e2ap_MiscellaneousCause_enum_t, UINT8_C(0))
typedef uint8_t e2ap_Cause_union_type_t;
__flatbuffers_define_integer_type(e2ap_Cause, e2ap_Cause_union_type_t, 8)
__flatbuffers_define_union(flatbuffers_, e2ap_Cause)
#define e2ap_Cause_NONE ((e2ap_Cause_union_type_t)UINT8_C(0))
#define e2ap_Cause_ricRequest ((e2ap_Cause_union_type_t)UINT8_C(1))
#define e2ap_Cause_ricService ((e2ap_Cause_union_type_t)UINT8_C(2))
#define e2ap_Cause_transportLayer ((e2ap_Cause_union_type_t)UINT8_C(3))
#define e2ap_Cause_protocol ((e2ap_Cause_union_type_t)UINT8_C(4))
#define e2ap_Cause_misc ((e2ap_Cause_union_type_t)UINT8_C(5))

static inline const char *e2ap_Cause_type_name(e2ap_Cause_union_type_t type)
{
    switch (type) {
    case e2ap_Cause_NONE: return "NONE";
    case e2ap_Cause_ricRequest: return "ricRequest";
    case e2ap_Cause_ricService: return "ricService";
    case e2ap_Cause_transportLayer: return "transportLayer";
    case e2ap_Cause_protocol: return "protocol";
    case e2ap_Cause_misc: return "misc";
    default: return "";
    }
}

static inline int e2ap_Cause_is_known_type(e2ap_Cause_union_type_t type)
{
    switch (type) {
    case e2ap_Cause_NONE: return 1;
    case e2ap_Cause_ricRequest: return 1;
    case e2ap_Cause_ricService: return 1;
    case e2ap_Cause_transportLayer: return 1;
    case e2ap_Cause_protocol: return 1;
    case e2ap_Cause_misc: return 1;
    default: return 0;
    }
}


struct e2ap_IECriticalityDiagnostics_table { uint8_t unused__; };

static inline size_t e2ap_IECriticalityDiagnostics_vec_len(e2ap_IECriticalityDiagnostics_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_IECriticalityDiagnostics_table_t e2ap_IECriticalityDiagnostics_vec_at(e2ap_IECriticalityDiagnostics_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_IECriticalityDiagnostics_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_IECriticalityDiagnostics)

__flatbuffers_define_scalar_field(0, e2ap_IECriticalityDiagnostics, criticality, e2ap_Criticality, e2ap_Criticality_enum_t, UINT8_C(0))
__flatbuffers_define_scalar_field(1, e2ap_IECriticalityDiagnostics, ieId, flatbuffers_uint16, uint16_t, UINT16_C(0))
__flatbuffers_define_scalar_field(2, e2ap_IECriticalityDiagnostics, typeOfError, e2ap_TypeOfError, e2ap_TypeOfError_enum_t, UINT8_C(0))

struct e2ap_CriticalityDiagnostics_table { uint8_t unused__; };

static inline size_t e2ap_CriticalityDiagnostics_vec_len(e2ap_CriticalityDiagnostics_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_CriticalityDiagnostics_table_t e2ap_CriticalityDiagnostics_vec_at(e2ap_CriticalityDiagnostics_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_CriticalityDiagnostics_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_CriticalityDiagnostics)

__flatbuffers_define_scalar_field(0, e2ap_CriticalityDiagnostics, procedureCode, flatbuffers_uint8, uint8_t, UINT8_C(0))
__flatbuffers_define_scalar_field(1, e2ap_CriticalityDiagnostics, triggeringMessage, e2ap_TriggeringMessage, e2ap_TriggeringMessage_enum_t, UINT8_C(0))
__flatbuffers_define_scalar_field(2, e2ap_CriticalityDiagnostics, procedureCriticality, e2ap_ProcedureCriticality, e2ap_ProcedureCriticality_enum_t, UINT8_C(0))
__flatbuffers_define_vector_field(3, e2ap_CriticalityDiagnostics, ieCriticalityDiagnostics, e2ap_IECriticalityDiagnostics_vec_t, 0)

struct e2ap_GlobalRicId_table { uint8_t unused__; };

static inline size_t e2ap_GlobalRicId_vec_len(e2ap_GlobalRicId_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_GlobalRicId_table_t e2ap_GlobalRicId_vec_at(e2ap_GlobalRicId_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_GlobalRicId_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_GlobalRicId)

__flatbuffers_define_struct_field(0, e2ap_GlobalRicId, plmn, e2ap_Plmn_struct_t, 0)
__flatbuffers_define_scalar_field(1, e2ap_GlobalRicId, nearRtRicId, flatbuffers_uint32, uint32_t, UINT32_C(0))
typedef uint8_t e2ap_GlobalE2NodeId_union_type_t;
__flatbuffers_define_integer_type(e2ap_GlobalE2NodeId, e2ap_GlobalE2NodeId_union_type_t, 8)
__flatbuffers_define_union(flatbuffers_, e2ap_GlobalE2NodeId)
#define e2ap_GlobalE2NodeId_NONE ((e2ap_GlobalE2NodeId_union_type_t)UINT8_C(0))
#define e2ap_GlobalE2NodeId_gNB ((e2ap_GlobalE2NodeId_union_type_t)UINT8_C(1))
#define e2ap_GlobalE2NodeId_engNB ((e2ap_GlobalE2NodeId_union_type_t)UINT8_C(2))
#define e2ap_GlobalE2NodeId_ngeNB ((e2ap_GlobalE2NodeId_union_type_t)UINT8_C(3))
#define e2ap_GlobalE2NodeId_eNB ((e2ap_GlobalE2NodeId_union_type_t)UINT8_C(4))

static inline const char *e2ap_GlobalE2NodeId_type_name(e2ap_GlobalE2NodeId_union_type_t type)
{
    switch (type) {
    case e2ap_GlobalE2NodeId_NONE: return "NONE";
    case e2ap_GlobalE2NodeId_gNB: return "gNB";
    case e2ap_GlobalE2NodeId_engNB: return "engNB";
    case e2ap_GlobalE2NodeId_ngeNB: return "ngeNB";
    case e2ap_GlobalE2NodeId_eNB: return "eNB";
    default: return "";
    }
}

static inline int e2ap_GlobalE2NodeId_is_known_type(e2ap_GlobalE2NodeId_union_type_t type)
{
    switch (type) {
    case e2ap_GlobalE2NodeId_NONE: return 1;
    case e2ap_GlobalE2NodeId_gNB: return 1;
    case e2ap_GlobalE2NodeId_engNB: return 1;
    case e2ap_GlobalE2NodeId_ngeNB: return 1;
    case e2ap_GlobalE2NodeId_eNB: return 1;
    default: return 0;
    }
}


struct e2ap_RicSubsequentAction_table { uint8_t unused__; };

static inline size_t e2ap_RicSubsequentAction_vec_len(e2ap_RicSubsequentAction_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_RicSubsequentAction_table_t e2ap_RicSubsequentAction_vec_at(e2ap_RicSubsequentAction_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_RicSubsequentAction_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_RicSubsequentAction)

__flatbuffers_define_scalar_field(0, e2ap_RicSubsequentAction, type, e2ap_RicSubsequentActionType, e2ap_RicSubsequentActionType_enum_t, UINT8_C(0))
__flatbuffers_define_scalar_field(1, e2ap_RicSubsequentAction, timeToWait, flatbuffers_uint32, uint32_t, UINT32_C(0))
typedef uint8_t e2ap_E2NodeCompConfUpdate_union_type_t;
__flatbuffers_define_integer_type(e2ap_E2NodeCompConfUpdate, e2ap_E2NodeCompConfUpdate_union_type_t, 8)
__flatbuffers_define_union(flatbuffers_, e2ap_E2NodeCompConfUpdate)
#define e2ap_E2NodeCompConfUpdate_NONE ((e2ap_E2NodeCompConfUpdate_union_type_t)UINT8_C(0))
#define e2ap_E2NodeCompConfUpdate_gnb ((e2ap_E2NodeCompConfUpdate_union_type_t)UINT8_C(1))
#define e2ap_E2NodeCompConfUpdate_en_gnb ((e2ap_E2NodeCompConfUpdate_union_type_t)UINT8_C(2))
#define e2ap_E2NodeCompConfUpdate_ng_enb ((e2ap_E2NodeCompConfUpdate_union_type_t)UINT8_C(3))
#define e2ap_E2NodeCompConfUpdate_enb ((e2ap_E2NodeCompConfUpdate_union_type_t)UINT8_C(4))

static inline const char *e2ap_E2NodeCompConfUpdate_type_name(e2ap_E2NodeCompConfUpdate_union_type_t type)
{
    switch (type) {
    case e2ap_E2NodeCompConfUpdate_NONE: return "NONE";
    case e2ap_E2NodeCompConfUpdate_gnb: return "gnb";
    case e2ap_E2NodeCompConfUpdate_en_gnb: return "en_gnb";
    case e2ap_E2NodeCompConfUpdate_ng_enb: return "ng_enb";
    case e2ap_E2NodeCompConfUpdate_enb: return "enb";
    default: return "";
    }
}

static inline int e2ap_E2NodeCompConfUpdate_is_known_type(e2ap_E2NodeCompConfUpdate_union_type_t type)
{
    switch (type) {
    case e2ap_E2NodeCompConfUpdate_NONE: return 1;
    case e2ap_E2NodeCompConfUpdate_gnb: return 1;
    case e2ap_E2NodeCompConfUpdate_en_gnb: return 1;
    case e2ap_E2NodeCompConfUpdate_ng_enb: return 1;
    case e2ap_E2NodeCompConfUpdate_enb: return 1;
    default: return 0;
    }
}


struct e2ap_gnbE2NodeCompConfUpdate_table { uint8_t unused__; };

static inline size_t e2ap_gnbE2NodeCompConfUpdate_vec_len(e2ap_gnbE2NodeCompConfUpdate_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_gnbE2NodeCompConfUpdate_table_t e2ap_gnbE2NodeCompConfUpdate_vec_at(e2ap_gnbE2NodeCompConfUpdate_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_gnbE2NodeCompConfUpdate_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_gnbE2NodeCompConfUpdate)

__flatbuffers_define_vector_field(0, e2ap_gnbE2NodeCompConfUpdate, ngap_gnb_cu_cp, flatbuffers_uint8_vec_t, 0)
__flatbuffers_define_vector_field(1, e2ap_gnbE2NodeCompConfUpdate, xnap_gnb_cu_cp, flatbuffers_uint8_vec_t, 0)
__flatbuffers_define_vector_field(2, e2ap_gnbE2NodeCompConfUpdate, e1ap_gnb_cu_cp, flatbuffers_uint8_vec_t, 0)
__flatbuffers_define_vector_field(3, e2ap_gnbE2NodeCompConfUpdate, f1ap_gnb_cu_cp, flatbuffers_uint8_vec_t, 0)

struct e2ap_en_gnbE2NodeCompConfUpdate_table { uint8_t unused__; };

static inline size_t e2ap_en_gnbE2NodeCompConfUpdate_vec_len(e2ap_en_gnbE2NodeCompConfUpdate_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_en_gnbE2NodeCompConfUpdate_table_t e2ap_en_gnbE2NodeCompConfUpdate_vec_at(e2ap_en_gnbE2NodeCompConfUpdate_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_en_gnbE2NodeCompConfUpdate_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_en_gnbE2NodeCompConfUpdate)

__flatbuffers_define_vector_field(0, e2ap_en_gnbE2NodeCompConfUpdate, x2ap_en_gnb, flatbuffers_uint8_vec_t, 0)

struct e2ap_ng_enbE2NodeCompConfUpdate_table { uint8_t unused__; };

static inline size_t e2ap_ng_enbE2NodeCompConfUpdate_vec_len(e2ap_ng_enbE2NodeCompConfUpdate_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_ng_enbE2NodeCompConfUpdate_table_t e2ap_ng_enbE2NodeCompConfUpdate_vec_at(e2ap_ng_enbE2NodeCompConfUpdate_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_ng_enbE2NodeCompConfUpdate_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_ng_enbE2NodeCompConfUpdate)

__flatbuffers_define_vector_field(0, e2ap_ng_enbE2NodeCompConfUpdate, ngap_ng_enb, flatbuffers_uint8_vec_t, 0)
__flatbuffers_define_vector_field(1, e2ap_ng_enbE2NodeCompConfUpdate, xap_ng_enb, flatbuffers_uint8_vec_t, 0)

struct e2ap_enbE2NodeCompConfUpdate_table { uint8_t unused__; };

static inline size_t e2ap_enbE2NodeCompConfUpdate_vec_len(e2ap_enbE2NodeCompConfUpdate_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_enbE2NodeCompConfUpdate_table_t e2ap_enbE2NodeCompConfUpdate_vec_at(e2ap_enbE2NodeCompConfUpdate_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_enbE2NodeCompConfUpdate_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_enbE2NodeCompConfUpdate)

__flatbuffers_define_vector_field(0, e2ap_enbE2NodeCompConfUpdate, s1ap_enb, flatbuffers_uint8_vec_t, 0)
__flatbuffers_define_vector_field(1, e2ap_enbE2NodeCompConfUpdate, x2ap_enb, flatbuffers_uint8_vec_t, 0)

struct e2ap_E2NodeCompConfUpdateAck_table { uint8_t unused__; };

static inline size_t e2ap_E2NodeCompConfUpdateAck_vec_len(e2ap_E2NodeCompConfUpdateAck_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_E2NodeCompConfUpdateAck_table_t e2ap_E2NodeCompConfUpdateAck_vec_at(e2ap_E2NodeCompConfUpdateAck_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_E2NodeCompConfUpdateAck_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_E2NodeCompConfUpdateAck)

__flatbuffers_define_scalar_field(0, e2ap_E2NodeCompConfUpdateAck, outcome, e2ap_E2NodeCompConfUpdateAckOutcome, e2ap_E2NodeCompConfUpdateAckOutcome_enum_t, UINT8_C(0))
__flatbuffers_define_union_field(flatbuffers_, 2, e2ap_E2NodeCompConfUpdateAck, cause, e2ap_Cause, 0)

struct e2ap_TransportLayerInformation_table { uint8_t unused__; };

static inline size_t e2ap_TransportLayerInformation_vec_len(e2ap_TransportLayerInformation_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_TransportLayerInformation_table_t e2ap_TransportLayerInformation_vec_at(e2ap_TransportLayerInformation_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_TransportLayerInformation_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_TransportLayerInformation)

__flatbuffers_define_vector_field(0, e2ap_TransportLayerInformation, transportLayerAddress, flatbuffers_uint8_vec_t, 0)
__flatbuffers_define_scalar_field(1, e2ap_TransportLayerInformation, transportLayerPort, flatbuffers_uint16, uint16_t, UINT16_C(0))
typedef uint8_t e2ap_E2NodeCompId_union_type_t;
__flatbuffers_define_integer_type(e2ap_E2NodeCompId, e2ap_E2NodeCompId_union_type_t, 8)
__flatbuffers_define_union(flatbuffers_, e2ap_E2NodeCompId)
#define e2ap_E2NodeCompId_NONE ((e2ap_E2NodeCompId_union_type_t)UINT8_C(0))
#define e2ap_E2NodeCompId_gnb_cu_up ((e2ap_E2NodeCompId_union_type_t)UINT8_C(1))
#define e2ap_E2NodeCompId_gnb_du ((e2ap_E2NodeCompId_union_type_t)UINT8_C(2))

static inline const char *e2ap_E2NodeCompId_type_name(e2ap_E2NodeCompId_union_type_t type)
{
    switch (type) {
    case e2ap_E2NodeCompId_NONE: return "NONE";
    case e2ap_E2NodeCompId_gnb_cu_up: return "gnb_cu_up";
    case e2ap_E2NodeCompId_gnb_du: return "gnb_du";
    default: return "";
    }
}

static inline int e2ap_E2NodeCompId_is_known_type(e2ap_E2NodeCompId_union_type_t type)
{
    switch (type) {
    case e2ap_E2NodeCompId_NONE: return 1;
    case e2ap_E2NodeCompId_gnb_cu_up: return 1;
    case e2ap_E2NodeCompId_gnb_du: return 1;
    default: return 0;
    }
}


struct e2ap_GNB_table { uint8_t unused__; };

static inline size_t e2ap_GNB_vec_len(e2ap_GNB_vec_t vec)
__flatbuffers_vec_len(vec)
static inline e2ap_GNB_table_t e2ap_GNB_vec_at(e2ap_GNB_vec_t vec, size_t i)
__flatbuffers_offset_vec_at(e2ap_GNB_table_t, vec, i, 0)
__flatbuffers_table_as_root(e2ap_GNB)

__flatbuffers_define_struct_field(0, e2ap_GNB, plmn, e2ap_Plmn_struct_t, 0)
__flatbuffers_define_scalar_field(1, e2ap_GNB, id, flatbuffers_uint32, uint32_t, UINT32_C(0))
__flatbuffers_define_scalar_field(2, e2ap_GNB, cu_up_id, flatbuffers_uint64, uint64_t, UINT64_C(0))
__flatbuffers_define_scalar_field(3, e2ap_GNB, du_id, flatbuffers_uint64, uint64_t, UINT64_C(0))


#include "flatcc/flatcc_epilogue.h"
#endif /* IE_DEFINITIONS_READER_H */
